home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / utility / 602 / crsrc / crsrc.c next >
Encoding:
C/C++ Source or Header  |  1991-12-07  |  36.8 KB  |  987 lines
  1. /******************************************************************************/
  2. /*                                                                            */
  3. /*                                  CRSRC                                     */
  4. /*                                                                            */
  5. /*  Converts resource files to linkable C source code with functions to       */
  6. /*  emulate the AES resource functions.                                       */
  7. /*                                                                            */
  8. /*      This is the source code for version 1.0 (first P.D. release).         */
  9. /*                                                                            */
  10. /*                          © Martin Packer 1990/91                           */
  11. /*                                                                            */
  12. /*          Compiler:           Lattice C version 5.06.02                     */
  13. /*          Compiler Options:   -ctf                                          */
  14. /*                                                                            */
  15. /* You're welcome to make changes to this program if you want to (I wouldn't  */
  16. /* have released the source code otherwise) but if you fix any bugs or make   */
  17. /* any huge improvements I'd quite like to know about them. I'd also like to  */
  18. /* know if you intend to distribute a modified version of the code.           */
  19. /* I also reserve the right to be credited as the original author.            */
  20. /******************************************************************************/
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <gemlib.h>
  24. #include <fcntl.h>
  25. #include <string.h>
  26. #include <ctype.h>
  27.  
  28. /* maximum number of resource files */
  29. #define MAX_RESOURCE_FILES 10
  30.  
  31. /* maximum number of strings in a resource */
  32. #define MAX_STRINGS 10000
  33.  
  34. /* array names */
  35. #define IMAGE_DATA_ARRAY    "CrsrcImgData"
  36. #define TEDINFO_ARRAY       "CrsrcTedinfo"
  37. #define ICONBLK_ARRAY       "CrsrcIconblk"  
  38. #define BITBLK_ARRAY        "CrsrcBitblk"
  39. #define FREE_STRING_ARRAY   "CrsrcFreeString"
  40. #define FREE_IMAGE_ARRAY    "CrsrcFreeImage"
  41. #define OBJECT_ARRAY        "CrsrcObject"
  42. #define TREE_ARRAY          "CrsrcTree"    
  43. char *Scope="static";   /* scope of the arrays in the destination file */
  44. char *Class="";         /* storage class of the arrays in the destination file */
  45.  
  46. char *ResourceFile[MAX_RESOURCE_FILES]; /* array of resource file names */
  47. int NoResourceFiles;                    /* number of resource files */
  48. int CurResource;                        /* current resource file being processed */
  49. int NoObjects[MAX_RESOURCE_FILES];      /* array for storing number of objects in each resource file */
  50.  
  51. char *DestFile=NULL;    /* destination file name */
  52. FILE *DestHdl;          /* destination file handle */
  53. char *RscBuf;           /* resource file buffer pointer */
  54. RSHDR *RscHdr;          /* resource file header pointer */
  55.  
  56. long StringOffset[MAX_STRINGS];  /* array for sorted string offsets in resource */
  57.  
  58. /******************************************************************************/
  59. /* Builds and sorts array of string offsets in resource.                      */
  60. /* We have to extract and sort all the string offsets                         */
  61. /* first so we can tell where they all start and end.                         */
  62. /******************************************************************************/
  63. void GetStrings(void)
  64. {
  65.     int stringno=0;         /* index for filling StringOffset[] */
  66.     unsigned short *rscptr; /* pointer to the first of the file offsets in the resource header */
  67.     unsigned short startoff;/* offset to the start of the string area */
  68.     unsigned short endoff;  /* offset to the end of the string area */
  69.     long *freestr;          /* pointer to free string pointer array */
  70.     OBJECT *objptr;         /* object pointer for extracting strings */
  71.     TEDINFO *tedptr;        /* tedinfo pointer for extracting strings */
  72.     ICONBLK *iconptr;       /* iconblk pointer for extracting string */
  73.     int i;
  74.  
  75.  
  76.     /* get pointer to start of string area in resource */
  77.     startoff=RscHdr->rsh_string;
  78.  
  79.     /* get offset to end of string area by looking for the next offset */
  80.     /* in the resource header */
  81.     rscptr=&(RscHdr->rsh_object);
  82.     endoff=RscHdr->rsh_rssize;
  83.     for(i=0;i<9;i++)    /* nine offsets in header */
  84.     {
  85.         if(rscptr[i]>startoff && rscptr[i]<endoff) endoff=rscptr[i];
  86.     };
  87.  
  88.     /* this should be the end of the last string so store it in the array */
  89.     StringOffset[stringno++]=endoff;
  90.     
  91.     /* extract free strings */
  92.     freestr=(long *)(RscBuf+RscHdr->rsh_frstr);
  93.     for(i=0; i<RscHdr->rsh_nstring && stringno<MAX_STRINGS; i++)
  94.     {
  95.         StringOffset[stringno++]=freestr[i];
  96.     };
  97.     
  98.     /* extract strings from objects */
  99.     objptr=(OBJECT *)(RscBuf+RscHdr->rsh_object);
  100.     for(i=0; i<RscHdr->rsh_nobs && stringno<MAX_STRINGS; i++)
  101.     {
  102.         switch((objptr)->ob_type)
  103.         {
  104.             case G_BUTTON:
  105.             case G_STRING:
  106.             case G_TITLE:
  107.                 /* ob_spec is a pointer to the string */
  108.                 StringOffset[stringno++]=(long)objptr->ob_spec;
  109.                 break;        
  110.  
  111.             case G_TEXT:
  112.             case G_BOXTEXT:
  113.             case G_FTEXT:
  114.             case G_FBOXTEXT:
  115.                 /* ob_spec is a pointer to a TEDINFO containing strings */
  116.                 tedptr=(TEDINFO *)(RscBuf+(long)objptr->ob_spec);
  117.                 StringOffset[stringno++]=(long)tedptr->te_ptext;
  118.                 StringOffset[stringno++]=(long)tedptr->te_ptmplt;
  119.                 StringOffset[stringno++]=(long)tedptr->te_pvalid;
  120.                 break;
  121.                 
  122.             case G_ICON:
  123.                 /* ob_spec is a pointer to an ICONBLK containing a string */
  124.                 iconptr=(ICONBLK *)(RscBuf+(long)objptr->ob_spec);
  125.                 StringOffset[stringno++]=(long)iconptr->ib_ptext;
  126.                 break;    
  127.         };
  128.         objptr++;
  129.     }; 
  130.  
  131.     if(stringno==MAX_STRINGS)
  132.     {
  133.         printf("Too many strings in resource file: %s\n", ResourceFile[CurResource]);
  134.     };
  135.  
  136.     /* sort the array */
  137.     lqsort(StringOffset,stringno);
  138. }
  139.  
  140. /******************************************************************************/
  141. /* Looks up the given string offset in StringOffset[] and returns index       */
  142. /******************************************************************************/
  143. int LookUpString(long stringoff)    /* string offset to look up */
  144. {
  145.     int i;
  146.     
  147.     for(i=0;stringoff>StringOffset[i] && StringOffset[i];i++);
  148.     
  149.     return(i);
  150. }
  151.  
  152. /******************************************************************************/
  153. /* Writes the given string from StringOffset[]                                */
  154. /******************************************************************************/
  155. void WriteString(int index)     /* index in StringOffset[] */
  156. {
  157.     char *startptr; /* start of string */
  158.     char *endptr;   /* end of string */
  159.     char *tp;    
  160.     char ch;
  161.  
  162.     startptr=RscBuf+StringOffset[index];
  163.     endptr=RscBuf+StringOffset[index+1]-1;
  164.     
  165.     fputc('\"',DestHdl);
  166.  
  167.     for(tp=startptr;tp<endptr;tp++)
  168.     {
  169.         ch=*tp;    
  170.  
  171.         switch(ch)
  172.         {
  173.             /* lexicals */
  174.             case '\"':
  175.                 fputs("\\\"",DestHdl);
  176.                 break;
  177.  
  178.             case '\'':
  179.                 fputs("\\\'",DestHdl);
  180.                 break;
  181.  
  182.             case '\\':
  183.                 fputs("\\\\",DestHdl);
  184.                 break;
  185.  
  186.             case '\n':
  187.                 fputs("\\n",DestHdl);
  188.                 break;
  189.                 
  190.             case '\r':
  191.                 fputs("\\r",DestHdl);
  192.                 break;
  193.                     
  194.             case '\0':
  195.                 fputs("\\0",DestHdl);
  196.                 break;
  197.                 
  198.             default:
  199.                 if(isprint(ch))
  200.                 {
  201.                     /* printables */
  202.                     fputc(ch,DestHdl);
  203.                 }
  204.                 else
  205.                 {
  206.                     /* unprintables */
  207.                     fprintf(DestHdl,"\\X%0.2X\"\"",ch);
  208.                 };
  209.         };
  210.     };
  211.  
  212.     fputc('\"',DestHdl);
  213. }
  214.  
  215. /******************************************************************************/
  216. /* Checks for free images and objects that use image data and returns         */
  217. /* non-0 if there are any. This is the only way to check if there is          */
  218. /* image data in the resource.                                                */
  219. /******************************************************************************/
  220. int CheckForImages(void)
  221. {
  222.     OBJECT *objptr;         /* object pointer */
  223.     unsigned short objtype; /* object type */
  224.     int i;
  225.  
  226.     if(RscHdr->rsh_nimages) return(1);
  227.     
  228.     objptr=(OBJECT *)(RscBuf+RscHdr->rsh_object);
  229.     for(i=0; i<RscHdr->rsh_nobs; i++)
  230.     {
  231.         objtype=(objptr++)->ob_type;
  232.         if(objtype==G_IMAGE || objtype==G_ICON) return(1);
  233.     }; 
  234.     
  235.     return(0);
  236. }
  237.  
  238. /******************************************************************************/
  239. /* Write image data from resource                                             */
  240. /******************************************************************************/
  241. void WriteImageData(void)
  242. {
  243.     unsigned short *rscptr;     /* pointer to the first of the file offsets in the resource header */
  244.     unsigned short *startptr;   /* pointer to the start of the image data */
  245.     unsigned short *endptr;     /* pointer to the end of the image data */
  246.     unsigned short *imageptr;   /* image data pointer */
  247.     int i;
  248.  
  249.     fprintf(DestHdl,"%s short %s %s%d[]=\n{", Scope, Class, IMAGE_DATA_ARRAY, CurResource);
  250.  
  251.     if(!CheckForImages())
  252.     {
  253.         fprintf(DestHdl,"\n        0       /* no image data */\n};\n\n");
  254.         return;
  255.     };
  256.  
  257.     startptr=(unsigned short *)(RscBuf+RscHdr->rsh_imdata);
  258.  
  259.     /* find end pointer by looking for the next pointer in the resource header */
  260.     rscptr=&(RscHdr->rsh_object);
  261.     endptr=(unsigned short *)(RscBuf+RscHdr->rsh_rssize);
  262.     for(i=0;i<9;i++)    /* nine offsets in header */
  263.     {
  264.         if(RscBuf+rscptr[i]>(char *)startptr && RscBuf+rscptr[i]<(char *)endptr) endptr=(unsigned short *)(RscBuf+rscptr[i]);
  265.     };
  266.  
  267.     imageptr=startptr;
  268.  
  269.     while(imageptr < endptr)
  270.     {
  271.             /* eight words per line */
  272.             if((imageptr-startptr)%8==0)
  273.             {
  274.                 fprintf(DestHdl,"\n/*%4d*/",(imageptr-startptr));
  275.             };
  276.  
  277.             fprintf(DestHdl,"0X%0.4X",*(imageptr++));
  278.  
  279.             /* print a comma if we're not finished */
  280.             if(imageptr < endptr) fprintf(DestHdl,", ");
  281.     };    
  282.     fprintf(DestHdl,"\n};\n\n");
  283. }
  284.  
  285. /******************************************************************************/
  286. /* Write TEDINFOs from resource                                               */
  287. /******************************************************************************/
  288. void WriteTedinfos(void)
  289. {
  290.     TEDINFO *tedarray;      /* TEDINFO array pointer */
  291.     int i;
  292.  
  293.     fprintf(DestHdl,"%s TEDINFO %s %s%d[]=\n{\n", Scope, Class, TEDINFO_ARRAY, CurResource);
  294.  
  295.     if(RscHdr->rsh_nted==0)
  296.     {
  297.         fprintf(DestHdl,"        NULL    /* no TEDINFO's */\n};\n\n");
  298.         return;
  299.     };
  300.     
  301.     tedarray=(TEDINFO *)(RscBuf+RscHdr->rsh_tedinfo);
  302.     for(i=0; i<RscHdr->rsh_nted; i++)
  303.     {
  304.         fprintf(DestHdl,"/*%4d*/",i);
  305.  
  306.         /* write text string */
  307.         WriteString(LookUpString((long)tedarray[i].te_ptext));
  308.         fprintf(DestHdl,",\n        ");
  309.  
  310.         /* write template string */
  311.         WriteString(LookUpString((long)tedarray[i].te_ptmplt));
  312.         fprintf(DestHdl,",\n        ");
  313.  
  314.         /* write validation string */
  315.         WriteString(LookUpString((long)tedarray[i].te_pvalid));
  316.         fprintf(DestHdl,",\n        ");
  317.  
  318.         /* write the other stuff */
  319.         fprintf(DestHdl,"%2d, %2d, %2d, 0X%0.4X, %2d, %2d, %2d, %2d",
  320.                 tedarray[i].te_font, tedarray[i].te_junk1, tedarray[i].te_just, 
  321.                 tedarray[i].te_color, tedarray[i].te_junk2, tedarray[i].te_thickness, 
  322.                 tedarray[i].te_txtlen, tedarray[i].te_tmplen);
  323.    
  324.         if(i<RscHdr->rsh_nted-1) fprintf(DestHdl,",\n");
  325.         else fprintf(DestHdl,"\n");
  326.     };
  327.  
  328.     fprintf(DestHdl,"};\n\n");
  329. }
  330.  
  331. /******************************************************************************/
  332. /* Write ICONBLKs from resource                                               */
  333. /******************************************************************************/
  334. void WriteIconblks(void)
  335. {
  336.     ICONBLK *iconarray;     /* ICONBLK array pointer */
  337.     int i;
  338.  
  339.     fprintf(DestHdl,"%s ICONBLK %s %s%d[]=\n{\n", Scope, Class, ICONBLK_ARRAY, CurResource);
  340.  
  341.     if(RscHdr->rsh_nib==0)
  342.     {
  343.         fprintf(DestHdl,"        NULL    /* no ICONBLK's */\n};\n\n");
  344.         return;
  345.     };
  346.     
  347.     iconarray=(ICONBLK *)(RscBuf+RscHdr->rsh_iconblk);
  348.     for(i=0; i<RscHdr->rsh_nib; i++)
  349.     {
  350.         fprintf(DestHdl,"/*%4d*/",i);
  351.  
  352.         /* write icon mask & data pointers */
  353.         fprintf(DestHdl,"&%s%d[%3ld], ",IMAGE_DATA_ARRAY, CurResource, 
  354.                 ((long)iconarray[i].ib_pmask-RscHdr->rsh_imdata)/sizeof(short));
  355.         fprintf(DestHdl,"&%s%d[%3ld], ",IMAGE_DATA_ARRAY, CurResource, 
  356.                 ((long)iconarray[i].ib_pdata-RscHdr->rsh_imdata)/sizeof(short));
  357.  
  358.         /* write icon string */
  359.         WriteString(LookUpString((long)iconarray[i].ib_ptext));
  360.         fprintf(DestHdl,",\n        ");
  361.  
  362.         /* write the other stuff */
  363.         fprintf(DestHdl,"0X%0.4X, 0X%0.4X, 0X%0.4X, 0X%0.4X, 0X%0.4X, 0X%0.4X, 0X%0.4X, 0X%0.4X, 0X%0.4X, 0X%0.4X, 0X%0.4X",
  364.                 iconarray[i].ib_char, iconarray[i].ib_xchar, iconarray[i].ib_ychar,    
  365.                 iconarray[i].ib_xicon, iconarray[i].ib_yicon, iconarray[i].ib_wicon,    
  366.                 iconarray[i].ib_hicon, iconarray[i].ib_xtext, iconarray[i].ib_ytext,    
  367.                 iconarray[i].ib_wtext, iconarray[i].ib_htext);   
  368.  
  369.         if(i<RscHdr->rsh_nib-1) fprintf(DestHdl,",\n");
  370.         else fprintf(DestHdl,"\n");
  371.     };
  372.  
  373.     fprintf(DestHdl,"};\n\n");
  374. }
  375.  
  376. /******************************************************************************/
  377. /* Write BITBLKs from resource                                                */
  378. /******************************************************************************/
  379. void WriteBitblks(void)
  380. {
  381.     BITBLK *bitarray;       /* BITBLK array pointer */
  382.     int i;
  383.  
  384.     fprintf(DestHdl,"%s BITBLK %s %s%d[]=\n{\n", Scope, Class, BITBLK_ARRAY, CurResource);
  385.  
  386.     if(RscHdr->rsh_nbb==0)
  387.     {
  388.         fprintf(DestHdl,"        NULL    /* no BITBLK's */\n};\n\n");
  389.         return;
  390.     };
  391.     
  392.     bitarray=(BITBLK *)(RscBuf+RscHdr->rsh_bitblk);
  393.     for(i=0; i<RscHdr->rsh_nbb; i++)
  394.     {
  395.         if(i%10==0) fprintf(DestHdl,"/*%4d*/",i);
  396.         else fprintf(DestHdl,"        ");
  397.  
  398.         /* write bit data pointer */
  399.         fprintf(DestHdl,"&%s%d[%3ld], ", IMAGE_DATA_ARRAY, CurResource, 
  400.                 ((long)bitarray[i].bi_pdata-RscHdr->rsh_imdata)/sizeof(short));
  401.  
  402.         /* write the other stuff */
  403.         fprintf(DestHdl,"0X%0.4X, 0X%0.4X, 0X%0.4X, 0X%0.4X, 0X%0.4X",
  404.                 bitarray[i].bi_wb, bitarray[i].bi_hl, bitarray[i].bi_x,
  405.                 bitarray[i].bi_y, bitarray[i].bi_color);
  406.         
  407.         if(i<RscHdr->rsh_nbb-1) fprintf(DestHdl,",\n");
  408.         else fprintf(DestHdl,"\n");
  409.     };
  410.  
  411.     fprintf(DestHdl,"};\n\n");
  412. }
  413.  
  414. /******************************************************************************/
  415. /* Write free strings from resource                                           */
  416. /******************************************************************************/
  417. void WriteFreeStrings(void)
  418. {
  419.     long *freestring;  /* free string array pointer */
  420.     int i;    
  421.  
  422.     fprintf(DestHdl,"%s char %s *%s%d[]=\n{\n", Scope, Class, FREE_STRING_ARRAY, CurResource);
  423.  
  424.     if(RscHdr->rsh_nstring==0)
  425.     {
  426.         fprintf(DestHdl,"        NULL    /* no free strings */\n};\n\n");
  427.         return;
  428.     };
  429.  
  430.     freestring=(long *)(RscBuf+RscHdr->rsh_frstr);
  431.     for(i=0;i<RscHdr->rsh_nstring;i++)
  432.     {
  433.         if(i%10==0) fprintf(DestHdl,"/*%4d*/",i);
  434.         else fprintf(DestHdl,"        ");
  435.  
  436.         /* write string by looking in offsets array */
  437.         WriteString(LookUpString(freestring[i]));
  438.    
  439.         if(i<RscHdr->rsh_nstring-1) fprintf(DestHdl,",\n");
  440.         else fprintf(DestHdl,"\n");
  441.     };
  442.  
  443.     fprintf(DestHdl,"};\n\n");
  444. }
  445.  
  446. /******************************************************************************/
  447. /* Write free images from resource                                            */
  448. /******************************************************************************/
  449. void WriteFreeImages(void)
  450. {
  451.     long *freeimage;  /* free image array pointer */
  452.     int i;    
  453.  
  454.     fprintf(DestHdl,"%s BITBLK %s *%s%d[]=\n{\n", Scope, Class, FREE_IMAGE_ARRAY, CurResource);
  455.  
  456.     if(RscHdr->rsh_nimages==0)
  457.     {
  458.         fprintf(DestHdl,"        NULL    /* no free images */\n};\n\n");
  459.         return;
  460.     };
  461.  
  462.     freeimage=(long *)(RscBuf+RscHdr->rsh_frimg);
  463.     for(i=0;i<RscHdr->rsh_nimages;i++)
  464.     {
  465.         if(i%10==0) fprintf(DestHdl,"/*%4d*/",i);
  466.         else fprintf(DestHdl,"        ");
  467.  
  468.         /* write pointer into BITBLK array */
  469.         fprintf(DestHdl,"&%s%d[%3ld], ", BITBLK_ARRAY, CurResource, 
  470.                 (freeimage[i]-RscHdr->rsh_bitblk)/sizeof(BITBLK));
  471.  
  472.         if(i<RscHdr->rsh_nimages-1) fprintf(DestHdl,",\n");
  473.         else fprintf(DestHdl,"\n");
  474.     };
  475.  
  476.     fprintf(DestHdl,"};\n\n");
  477. }
  478.  
  479. /******************************************************************************/
  480. /* Write OBJECTs from resource                                                */
  481. /******************************************************************************/
  482. void WriteObjects(void)
  483. {
  484.     OBJECT *objarray;       /* OBJECT array pointer */
  485.     int i;
  486.  
  487.     fprintf(DestHdl,"%s OBJECT %s %s%d[]=\n{\n", Scope, Class, OBJECT_ARRAY, CurResource);
  488.  
  489.     if(RscHdr->rsh_nobs==0)
  490.     {
  491.         fprintf(DestHdl,"        NULL    /* no OBJECT's */\n};\n\n");
  492.         return;
  493.     };
  494.     
  495.     objarray=(OBJECT *)(RscBuf+RscHdr->rsh_object);
  496.     for(i=0; i<RscHdr->rsh_nobs; i++)
  497.     {
  498.         if(i%10==0) fprintf(DestHdl,"/*%4d*/",i);
  499.         else fprintf(DestHdl,"        ");
  500.  
  501.         /* write related object indexes */
  502.         fprintf(DestHdl,"%3d, %3d, %3d, ",
  503.                 objarray[i].ob_next, objarray[i].ob_head, objarray[i].ob_tail);
  504.  
  505.         /* write object type (use type name, it makes things much clearer) */
  506.         switch(objarray[i].ob_type)
  507.         {
  508.             case G_BOX:
  509.                 fprintf(DestHdl,"G_BOX     ,");
  510.                 break;
  511.                 
  512.             case G_TEXT:
  513.                 fprintf(DestHdl,"G_TEXT    ,");
  514.                 break;
  515.                 
  516.             case G_BOXTEXT:
  517.                 fprintf(DestHdl,"G_BOXTEXT ,");
  518.                 break;
  519.                 
  520.             case G_IMAGE:
  521.                 fprintf(DestHdl,"G_IMAGE   ,");
  522.                 break;
  523.                 
  524.             case G_PROGDEF:
  525.                 fprintf(DestHdl,"G_PROGDEF ,");
  526.                 break;
  527.                 
  528.             case G_IBOX:
  529.                 fprintf(DestHdl,"G_IBOX    ,");
  530.                 break;
  531.                 
  532.             case G_BUTTON:
  533.                 fprintf(DestHdl,"G_BUTTON  ,");
  534.                 break;
  535.                 
  536.             case G_BOXCHAR:
  537.                 fprintf(DestHdl,"G_BOXCHAR ,");
  538.                 break;
  539.                 
  540.             case G_STRING:
  541.                 fprintf(DestHdl,"G_STRING  ,");
  542.                 break;
  543.                 
  544.             case G_FTEXT:
  545.                 fprintf(DestHdl,"G_FTEXT   ,");
  546.                 break;
  547.                 
  548.             case G_FBOXTEXT:
  549.                 fprintf(DestHdl,"G_FBOXTEXT,");
  550.                 break;
  551.                 
  552.             case G_ICON:
  553.                 fprintf(DestHdl,"G_ICON    ,");
  554.                 break;
  555.                 
  556.             case G_TITLE:
  557.                 fprintf(DestHdl,"G_TITLE   ,");
  558.                 break;
  559.         };
  560.  
  561.         /* write object state & flags */
  562.         fprintf(DestHdl,"0X%0.4X, 0x%0.4X, ", 
  563.                 objarray[i].ob_flags, objarray[i].ob_state);
  564.  
  565.         /* write object spec. (dependent on object type) */
  566.         switch(objarray[i].ob_type)
  567.         {
  568.             case G_BOX:
  569.             case G_IBOX:
  570.             case G_BOXCHAR:
  571.                 /* bit flags etc. */
  572.                 fprintf(DestHdl,"(void *)0X%0.8X, ",objarray[i].ob_spec);
  573.                 break;
  574.                 
  575.             case G_TEXT:
  576.             case G_BOXTEXT:
  577.             case G_FTEXT:
  578.             case G_FBOXTEXT:
  579.                 /* TEDINFO pointer */
  580.                 fprintf(DestHdl,"&%s%d[%3d], ", TEDINFO_ARRAY, CurResource, 
  581.                         ((long)objarray[i].ob_spec-RscHdr->rsh_tedinfo)/sizeof(TEDINFO));
  582.                 break;           
  583.  
  584.             case G_IMAGE:
  585.                 /* BITBLK pointer */
  586.                 fprintf(DestHdl,"&%s%d[%3d], ", BITBLK_ARRAY, CurResource, 
  587.                         ((long)objarray[i].ob_spec-RscHdr->rsh_bitblk)/sizeof(BITBLK));
  588.                 break;           
  589.  
  590.             case G_PROGDEF:
  591.                 /* APPLBLK pointer should be initialised be application */
  592.                 fputs("NULL, ",DestHdl);
  593.                 break;           
  594.  
  595.             case G_BUTTON:
  596.             case G_STRING:
  597.             case G_TITLE:
  598.                 /* string */
  599.                 WriteString(LookUpString((long)objarray[i].ob_spec));
  600.                 fputs(", ",DestHdl);
  601.                 break;
  602.  
  603.             case G_ICON:
  604.                 /* ICONBLK pointer */
  605.                 fprintf(DestHdl,"&%s%d[%3d], ", ICONBLK_ARRAY, CurResource, 
  606.                         ((long)objarray[i].ob_spec-RscHdr->rsh_iconblk)/sizeof(ICONBLK));
  607.                 break;           
  608.         };
  609.  
  610.         /* write object x, y, width & height */
  611.         fprintf(DestHdl,"0X%0.4X, 0X%0.4X, 0X%0.4X, 0X%0.4X", 
  612.                 objarray[i].ob_x, objarray[i].ob_y,        
  613.                 objarray[i].ob_width, objarray[i].ob_height);       
  614.  
  615.         if(i<RscHdr->rsh_nobs-1) fprintf(DestHdl,",\n");
  616.         else fprintf(DestHdl,"\n");
  617.     };
  618.  
  619.     fprintf(DestHdl,"};\n\n");
  620. }
  621.  
  622. /******************************************************************************/
  623. /* Write trees from resource                                                  */
  624. /******************************************************************************/
  625. void WriteTrees(void)
  626. {
  627.     long *treearray;    /* tree array pointer */
  628.     int i;    
  629.  
  630.     fprintf(DestHdl,"%s OBJECT %s *%s%d[]=\n{\n", Scope, Class, TREE_ARRAY, CurResource);
  631.  
  632.     if(RscHdr->rsh_ntree==0)
  633.     {
  634.         fprintf(DestHdl,"        NULL    /* no trees */\n};\n\n");
  635.         return;
  636.     };
  637.  
  638.     treearray=(long *)(RscBuf+RscHdr->rsh_trindex);
  639.     for(i=0;i<RscHdr->rsh_ntree;i++)
  640.     {
  641.         fprintf(DestHdl,"/*%4d*/",i);
  642.  
  643.         /* write pointer into OBJECT array */
  644.         fprintf(DestHdl,"&%s%d[%3ld]",OBJECT_ARRAY, CurResource, 
  645.                 (treearray[i]-RscHdr->rsh_object)/sizeof(OBJECT));
  646.  
  647.         if(i<RscHdr->rsh_ntree-1) fprintf(DestHdl,",\n");
  648.         else fprintf(DestHdl,"\n");
  649.     };
  650.  
  651.     fprintf(DestHdl,"};\n\n");
  652. }
  653.  
  654.  
  655. /******************************************************************************/
  656. /* Write header code                                                          */
  657. /******************************************************************************/
  658. void WriteHeader(void)
  659. {
  660.     int i;
  661.  
  662.     fprintf(DestHdl,"/******************************************************************************/\n");
  663.     fprintf(DestHdl,"/*      CRSRC extracted resource data from:                                   */\n");
  664.     for(i=0; i<NoResourceFiles; i++)
  665.     {
  666.         fprintf(DestHdl,"/*      %-64s      */\n",ResourceFile[i]);
  667.     };
  668.     fprintf(DestHdl,"/******************************************************************************/\n");
  669.  
  670.     fprintf(DestHdl,"#include <stdio.h>\n");
  671.     fprintf(DestHdl,"#include <gemlib.h>\n");
  672.     fprintf(DestHdl,"#include <string.h>\n\n");
  673.     fprintf(DestHdl,"#define NO_RESOURCE_FILES %d\n\n", NoResourceFiles);
  674.     fprintf(DestHdl,"%s int CrsrcFlag=0;\n\n", Scope);
  675.     fprintf(DestHdl,"%s short *%s;\n", Scope, IMAGE_DATA_ARRAY);
  676.     fprintf(DestHdl,"%s TEDINFO *%s;\n", Scope, TEDINFO_ARRAY);
  677.     fprintf(DestHdl,"%s ICONBLK *%s;\n", Scope, ICONBLK_ARRAY);  
  678.     fprintf(DestHdl,"%s BITBLK *%s;\n", Scope, BITBLK_ARRAY);
  679.     fprintf(DestHdl,"%s char **%s;\n", Scope, FREE_STRING_ARRAY);
  680.     fprintf(DestHdl,"%s BITBLK **%s;\n", Scope, FREE_IMAGE_ARRAY);
  681.     fprintf(DestHdl,"%s OBJECT *%s;\n", Scope, OBJECT_ARRAY);
  682.     fprintf(DestHdl,"%s OBJECT **%s;\n\n", Scope, TREE_ARRAY);    
  683. }
  684.  
  685. /******************************************************************************/
  686. /* Write AES emulation functions                                              */
  687. /******************************************************************************/
  688. void WriteFunctions(void)
  689. {
  690.     int i;
  691.     
  692.     fprintf(DestHdl,   "void CrsrcEnable(void)\n");
  693.     fprintf(DestHdl,   "{\n");
  694.     fprintf(DestHdl,   "    CrsrcFlag=1;\n");
  695.     fprintf(DestHdl,   "}\n");     
  696.     fprintf(DestHdl,   "\n");
  697.     fprintf(DestHdl,   "int Crsrc_load(char *filename)\n");
  698.     fprintf(DestHdl,   "{\n");
  699.     fprintf(DestHdl,   "    int i,j;\n");
  700.     fprintf(DestHdl,   "    static struct\n");
  701.     fprintf(DestHdl,   "    {\n");
  702.     fprintf(DestHdl,   "        char *FileName;\n");
  703.     fprintf(DestHdl,   "        int NoObjects;\n");
  704.     fprintf(DestHdl,   "        short *%s;\n", IMAGE_DATA_ARRAY);
  705.     fprintf(DestHdl,   "        TEDINFO *%s;\n", TEDINFO_ARRAY);
  706.     fprintf(DestHdl,   "        ICONBLK *%s;\n", ICONBLK_ARRAY);  
  707.     fprintf(DestHdl,   "        BITBLK *%s;\n", BITBLK_ARRAY);
  708.     fprintf(DestHdl,   "        char **%s;\n", FREE_STRING_ARRAY);
  709.     fprintf(DestHdl,   "        BITBLK **%s;\n", FREE_IMAGE_ARRAY);
  710.     fprintf(DestHdl,   "        OBJECT *%s;\n", OBJECT_ARRAY);
  711.     fprintf(DestHdl,   "        OBJECT **%s;\n", TREE_ARRAY);    
  712.     fprintf(DestHdl,   "    }\n");
  713.     fprintf(DestHdl,   "    resource[]=\n");
  714.     fprintf(DestHdl,   "    {\n");
  715.     for(i=0; i<NoResourceFiles; i++)
  716.     {
  717.         fprintf(DestHdl,   "        \"%s\", %d, %s%d, %s%d, %s%d, %s%d, %s%d, %s%d, %s%d, %s%d",
  718.                 ResourceFile[i], NoObjects[i], IMAGE_DATA_ARRAY, i, 
  719.                 TEDINFO_ARRAY, i, ICONBLK_ARRAY, i, BITBLK_ARRAY, i,
  720.                 FREE_STRING_ARRAY, i, FREE_IMAGE_ARRAY, i,
  721.                 OBJECT_ARRAY, i, TREE_ARRAY, i);
  722.         if(i<NoResourceFiles-1) fprintf(DestHdl,",\n");
  723.         else fprintf(DestHdl,"\n");
  724.     };
  725.     fprintf(DestHdl,   "    };\n");
  726.     fprintf(DestHdl,   "\n");
  727.     fprintf(DestHdl,   "    if(CrsrcFlag)\n");
  728.     fprintf(DestHdl,   "    {\n");
  729.     fprintf(DestHdl,   "        for(i=0; strcmpi(filename, resource[i].FileName) && i<NO_RESOURCE_FILES; i++)\n");
  730.     fprintf(DestHdl,   "        {\n");
  731.     fprintf(DestHdl,   "        };\n");
  732.     fprintf(DestHdl,   "        if(i==NO_RESOURCE_FILES)\n");
  733.     fprintf(DestHdl,   "        {\n");
  734.     fprintf(DestHdl,   "            return(0);\n");
  735.     fprintf(DestHdl,   "        };\n");
  736.     fprintf(DestHdl,   "\n");
  737.     fprintf(DestHdl,   "        %s=resource[i].%s;\n", IMAGE_DATA_ARRAY, IMAGE_DATA_ARRAY);
  738.     fprintf(DestHdl,   "        %s=resource[i].%s;\n", TEDINFO_ARRAY, TEDINFO_ARRAY);
  739.     fprintf(DestHdl,   "        %s=resource[i].%s;\n", ICONBLK_ARRAY, ICONBLK_ARRAY);  
  740.     fprintf(DestHdl,   "        %s=resource[i].%s;\n", BITBLK_ARRAY, BITBLK_ARRAY);
  741.     fprintf(DestHdl,   "        %s=resource[i].%s;\n", FREE_STRING_ARRAY, FREE_STRING_ARRAY);
  742.     fprintf(DestHdl,   "        %s=resource[i].%s;\n", FREE_IMAGE_ARRAY, FREE_IMAGE_ARRAY);
  743.     fprintf(DestHdl,   "        %s=resource[i].%s;\n", OBJECT_ARRAY, OBJECT_ARRAY);
  744.     fprintf(DestHdl,   "        %s=resource[i].%s;\n", TREE_ARRAY, TREE_ARRAY);
  745.     fprintf(DestHdl,   "\n");
  746.     fprintf(DestHdl,   "        for(j=0; j<resource[i].NoObjects; j++)\n");
  747.     fprintf(DestHdl,   "        {\n");
  748.     fprintf(DestHdl,   "            rsrc_obfix(%s, j);\n", OBJECT_ARRAY);
  749.     fprintf(DestHdl,   "        };\n");
  750.     fprintf(DestHdl,   "        return(1);\n"); 
  751.     fprintf(DestHdl,   "    }\n");
  752.     fprintf(DestHdl,   "    else\n");
  753.     fprintf(DestHdl,   "    {\n");
  754.     fprintf(DestHdl,   "        return(rsrc_load(filename));\n");
  755.     fprintf(DestHdl,   "    }\n");
  756.     fprintf(DestHdl,   "}\n");     
  757.     fprintf(DestHdl,   "\n");
  758.     fprintf(DestHdl,   "int Crsrc_free(void)\n");
  759.     fprintf(DestHdl,   "{\n");
  760.     fprintf(DestHdl,   "    if(CrsrcFlag)\n");
  761.     fprintf(DestHdl,   "    {\n");
  762.     fprintf(DestHdl,   "        return(1);\n");
  763.     fprintf(DestHdl,   "    }\n");
  764.     fprintf(DestHdl,   "    else\n");
  765.     fprintf(DestHdl,   "    {\n");
  766.     fprintf(DestHdl,   "        return(rsrc_free());\n");
  767.     fprintf(DestHdl,   "    };\n");
  768.     fprintf(DestHdl,   "}\n");
  769.     fprintf(DestHdl,   "\n");
  770.     fprintf(DestHdl,   "int Crsrc_obfix(OBJECT *tree, int index)\n");
  771.     fprintf(DestHdl,   "{\n");
  772.     fprintf(DestHdl,   "    return(rsrc_obfix(tree, index));\n");
  773.     fprintf(DestHdl,   "}\n");
  774.     fprintf(DestHdl,   "\n");
  775.     fprintf(DestHdl,   "int Crsrc_gaddr(int type, int index, void *addr)\n");
  776.     fprintf(DestHdl,   "{\n");
  777.     fprintf(DestHdl,   "    if(CrsrcFlag)\n");
  778.     fprintf(DestHdl,   "    {\n");
  779.     fprintf(DestHdl,   "        switch(type)\n");
  780.     fprintf(DestHdl,   "        {\n");
  781.     fprintf(DestHdl,   "            case R_TREE:\n");
  782.     fprintf(DestHdl,   "                *((OBJECT **)addr)=%s[index];\n",TREE_ARRAY);
  783.     fprintf(DestHdl,   "                break;\n");
  784.     fprintf(DestHdl,   "\n");
  785.     fprintf(DestHdl,   "            case R_OBJECT:\n");
  786.     fprintf(DestHdl,   "                *((OBJECT **)addr)=&%s[index];\n",OBJECT_ARRAY);
  787.     fprintf(DestHdl,   "                break;\n");
  788.     fprintf(DestHdl,   "\n");
  789.     fprintf(DestHdl,   "            case R_STRING:\n");
  790.     fprintf(DestHdl,   "                *((char **)addr)=%s[index];\n",FREE_STRING_ARRAY);
  791.     fprintf(DestHdl,   "                break;\n");
  792.     fprintf(DestHdl,   "\n");
  793.     fprintf(DestHdl,   "            case R_IMAGEDATA:\n");
  794.     fprintf(DestHdl,   "                *((BITBLK **)addr)=%s[index];\n",FREE_IMAGE_ARRAY);
  795.     fprintf(DestHdl,   "                break;\n");
  796.     fprintf(DestHdl,   "\n");
  797.     fprintf(DestHdl,   "            case R_FRSTR:\n");
  798.     fprintf(DestHdl,   "                *((char ***)addr)=%s;\n",FREE_STRING_ARRAY);
  799.     fprintf(DestHdl,   "                break;\n");
  800.     fprintf(DestHdl,   "\n");
  801.     fprintf(DestHdl,   "            case R_FRIMG:\n");
  802.     fprintf(DestHdl,   "                *((BITBLK ***)addr)=%s;\n",FREE_IMAGE_ARRAY);
  803.     fprintf(DestHdl,   "                break;\n");
  804.     fprintf(DestHdl,   "        };\n");
  805.     fprintf(DestHdl,   "        return(1);\n");
  806.     fprintf(DestHdl,   "    }\n");
  807.     fprintf(DestHdl,   "    else\n");
  808.     fprintf(DestHdl,   "    {\n");
  809.     fprintf(DestHdl,   "        return(rsrc_gaddr(type, index, addr));\n");
  810.     fprintf(DestHdl,   "    };\n");
  811.     fprintf(DestHdl,   "}\n");
  812.     fprintf(DestHdl,   "\n");
  813.     fprintf(DestHdl,   "int Crsrc_saddr(int type, int index, void *addr)\n");
  814.     fprintf(DestHdl,   "{\n");
  815.     fprintf(DestHdl,   "    if(CrsrcFlag)\n");
  816.     fprintf(DestHdl,   "    {\n");
  817.     fprintf(DestHdl,   "        switch(type)\n");
  818.     fprintf(DestHdl,   "        {\n");
  819.     fprintf(DestHdl,   "            case R_STRING:\n");
  820.     fprintf(DestHdl,   "                %s[index]=addr;\n",FREE_STRING_ARRAY);
  821.     fprintf(DestHdl,   "                break;\n");
  822.     fprintf(DestHdl,   "\n");
  823.     fprintf(DestHdl,   "            case R_IMAGEDATA:\n");
  824.     fprintf(DestHdl,   "                %s[index]=addr;\n",FREE_IMAGE_ARRAY);
  825.     fprintf(DestHdl,   "                break;\n");
  826.     fprintf(DestHdl,   "        };\n");
  827.     fprintf(DestHdl,   "        return(1);\n");
  828.     fprintf(DestHdl,   "    }\n");
  829.     fprintf(DestHdl,   "    else\n");
  830.     fprintf(DestHdl,   "    {\n");
  831.     fprintf(DestHdl,   "        return(rsrc_saddr(type, index, addr));\n");
  832.     fprintf(DestHdl,   "    };\n");
  833.     fprintf(DestHdl,   "}\n");
  834. }
  835.  
  836. /******************************************************************************/
  837. /* Loads a resource file into a malloc()'d buffer.                            */
  838. /* Returns a pointer to the buffer or NULL if error.                          */
  839. /******************************************************************************/
  840. char *LoadResource(char *filename)
  841. {
  842.     int fh;         /* file handle */
  843.     long flen;      /* file length */
  844.     char *buffer;   /* buffer pointer to return */
  845.  
  846.     if((fh=open(filename,O_RDONLY | O_RAW))==-1)
  847.     {
  848.         return(NULL);
  849.     };
  850.     
  851.     if((flen=filelength(fh))==-1)
  852.     {
  853.         close(fh);
  854.         return(NULL);
  855.     };
  856.  
  857.     if((buffer=malloc(flen+1))==NULL)
  858.     {
  859.         close(fh);
  860.         return(NULL);
  861.     };
  862.  
  863.     if(read(fh,buffer,flen)!=flen)
  864.     {
  865.         close(fh);
  866.         free(buffer);
  867.         return(NULL);
  868.     };
  869.  
  870.     close(fh);
  871.  
  872.     return(buffer);
  873. }
  874.  
  875. /******************************************************************************/
  876. /* Get command line parameters - sets various flags and fills ResourceFile[]  */
  877. /******************************************************************************/
  878. void GetPar(int argc, char **argv)
  879. {
  880.     int i;
  881.  
  882.     NoResourceFiles=0;
  883.     for(i=1;i<argc;i++)
  884.     {
  885.         if(argv[i][0]=='-' || argv[1][0]=='/')
  886.         {
  887.             switch(toupper(argv[i][1]))
  888.             {
  889.                 case 'O':   /* send output to file */
  890.                     DestFile=&argv[i][2];
  891.                     break;
  892.  
  893.                 case 'P':   /* send output to printer */
  894.                     DestHdl=stdprt;
  895.                     break;
  896.  
  897.                 case 'E':   /* make arrays external */
  898.                     Scope="";
  899.                     break;
  900.  
  901.                 case 'C':   /* set array storage class */
  902.                     Class=&argv[i][2];
  903.                     break;
  904.             };
  905.         }
  906.         else
  907.         {
  908.             ResourceFile[NoResourceFiles++]=argv[i];
  909.         };
  910.     };
  911. }
  912.  
  913. /******************************************************************************/
  914. /*                                      MAIN                                  */
  915. /******************************************************************************/
  916. void main(int argc, char **argv)
  917. {
  918.     if(argc<2)
  919.     {
  920.         printf("CRSRC Version 1.0                                           © Martin Packer 1991\n");
  921.         printf("Converts one or more GEM resource files to a linkable C source code module\n");
  922.         printf("with functions to emulate the AES resource functions.\n");
  923.         printf("USAGE: CRSRC <rsc file 1> [rsc file 2...] [-p|-o<filename>] [-e] [-c<class>]\n");
  924.         printf("       -o<filename> sends ouput to file\n");
  925.         printf("       -p           sends output to printer\n");
  926.         printf("       -e           gives the resource arrays external linkage (default static)\n");  
  927.         printf("       -c<class>    sets the storage class of the resource arrays\n");           
  928.         printf("If -o or -p not used, code is sent to standard output.\n"); 
  929.         printf("Press a key...\n");
  930.         exit(EXIT_FAILURE);
  931.     };
  932.  
  933.     /* read command line parameters */
  934.     GetPar(argc,argv);
  935.     
  936.     /* if no destination file given send it to stdout */
  937.     if(DestFile==NULL)
  938.     {
  939.         DestHdl=stdout;
  940.     }
  941.     else if((DestHdl=fopen(DestFile,"w"))==NULL)
  942.     {
  943.         printf("Can't open output file %s\n",DestFile);
  944.         exit(EXIT_FAILURE);
  945.     };
  946.  
  947.     WriteHeader();  /* write header code */
  948.  
  949.     for(CurResource=0; CurResource<NoResourceFiles; CurResource++)
  950.     {
  951.         if(RscBuf=LoadResource(ResourceFile[CurResource]))
  952.         {
  953.             RscHdr=(RSHDR *)RscBuf;    
  954.             NoObjects[CurResource]=RscHdr->rsh_nobs;
  955.             GetStrings();       /* extract string offsets from resource */
  956.  
  957.             fprintf(DestHdl,"/******** Data from %s ********/\n\n", ResourceFile[CurResource]);
  958.  
  959.             WriteImageData();
  960.             WriteTedinfos();
  961.             WriteIconblks();
  962.             WriteBitblks();
  963.             WriteFreeStrings();
  964.             WriteFreeImages();
  965.             WriteObjects();
  966.             WriteTrees();
  967.  
  968.             fprintf(DestHdl,"\n\n\n");
  969.  
  970.             free(RscBuf);
  971.         }
  972.         else
  973.         {
  974.             printf("Error loading Resource file %s\n", ResourceFile[CurResource]);
  975.         };
  976.  
  977.     };
  978.  
  979.     fprintf(DestHdl,"/******** AES emulation functions ********/\n\n");
  980.     
  981.     WriteFunctions();
  982.  
  983.     fclose(DestHdl);
  984.  
  985.     exit(EXIT_SUCCESS);
  986. }
  987.